Hur ändrar jag befintliga, opushade meddelanden?

Ändra det senaste meddelandet
git commit --amend
öppnar din redaktör så att du kan ändra meddelandet om det senaste engagemanget. Dessutom kan du ställa in kommuniceringsmeddelandet direkt i kommandoraden med:
git commit --amend -m "New commit message"
... detta kan dock göra flerradiga meddelanden eller små korrigeringar mer besvärliga att skriva in.
Se till att du inte har några ändringar i arbetskopia innan du gör detta, annars blir de också engagerade. (Ostadierade förändringar kommer inte att begås.)
Ändra meddelandet om ett engagemang som du redan har skickat till din avlägsna gren
Om du redan har tryckt på din uppdrag till din avlägsna gren, måste du - efter att du ändrat ditt engagemang lokalt (som beskrivs ovan) också tvinga push-uppdraget med:
git push   --force
# Eller
git push   -f
Varning: tvångstryckning kommer att skriva över den avlägsna grenen med tillståndet för din lokala. Om det finns åtaganden på den avlägsna grenen som du inte har i din lokala filial förlorar du dessa åtaganden.
Varning: var försiktig med att ändra åtaganden som du redan har delat med andra människor. Ändringsförpliktelser skriver i huvudsak om att de har olika SHA-ID: n, vilket utgör ett problem om andra har kopior av det gamla åtagandet som du har skrivit om. Alla som har en kopia av det gamla engagemanget måste synkronisera sitt arbete med ditt nyligen omskrivna engagemang, vilket ibland kan vara svårt, så se till att du samordnar med andra när du försöker skriva om delad engagemangshistorik, eller bara undvik att skriva om delade åtaganden sammanlagt.
Utför en interaktiv rebase
Ett annat alternativ är att använda interaktiv rebase.
Detta gör att du kan redigera alla meddelanden du vill uppdatera även om det inte är det senaste meddelandet.
Följ dessa steg för att göra en Git squash:
// n är antalet åtaganden upp till det senaste åtagandet du vill kunna redigera
git rebase -i HEAD ~ n
När du har squashat dina åtaganden - välj e / r för att redigera meddelandet:
Viktig anmärkning om interaktiv rebase
När du använder git rebase -i HEAD ~ n kan det vara mer än n kommit. Git kommer att "samla" alla åtaganden i de sista n-åtagandena, och om det fanns en sammanslagning någonstans mellan det intervallet ser du också alla åtaganden, så resultatet blir n +.
Bra tips:
Om du måste göra det i mer än en enda gren och du kan möta konflikter när du ändrar innehållet, ställ in git rerere och låt Git lösa dessa konflikter automatiskt åt dig.
Dokumentation
git-commit (1) Manuell sida
git-rebase (1) Manuell sida
git-push (1) Manuell sida
|
git commit --ändra -m "ditt nya meddelande"
|
Om det åtagande du vill åtgärda inte är det senaste:
git rebase - interaktiv $ parent_of_flawed_commit
Om du vill åtgärda flera felaktiga åtaganden, skicka föräldern till den äldsta av dem.
En redaktör kommer fram med en lista över alla åtaganden sedan den du gav.
Ändra valet för att omformulera (eller på gamla versioner av Git, för att redigera) framför alla åtaganden du vill fixa.
När du har sparat kommer Git att spela upp de listade åtagandena.
För varje engagemang du vill omformulera kommer Git att släppa tillbaka dig till din redaktör. För varje engagemang du vill redigera släpper Git dig i skalet. Om du är i skalet:
Ändra engagemanget på vilket sätt du vill.
git commit --amend
git rebase - fortsätt
Det mesta av denna sekvens kommer att förklaras för dig genom utmatningen av de olika kommandona när du går. Det är väldigt lätt; du behöver inte memorera det - kom bara ihåg att git rebase --interactive låter dig korrigera åtaganden oavsett hur länge sedan de var.
Observera att du inte vill ändra åtaganden som du redan har tryckt på. Eller kanske gör du det, men i så fall måste du vara mycket noga med att kommunicera med alla som kan ha dragit ditt engagemang och gjort arbete ovanpå dem. Hur återställer / återsynkroniserar jag efter att någon har tryckt en rebase eller en återställning till en publicerad gren?
|
För att ändra det tidigare åtagandet gör du de ändringar du vill ha och genomför dessa ändringar och kör sedan
git commit --amend
Detta öppnar en fil i din textredigerare som representerar ditt nya engagemangsmeddelande. Det börjar fyllas med texten från ditt gamla meddelande. Ändra engagemangsmeddelandet som du vill, spara sedan filen och avsluta din redigerare för att avsluta.
För att ändra det tidigare åtagandet och behålla samma loggmeddelande, kör
git commit --ändra -C HEAD
För att fixa det tidigare åtagandet genom att ta bort det helt, kör
git reset - hård HEAD ^
Om du vill redigera mer än ett kommuniceringsmeddelande, kör
git rebase -i HEAD ~ commit_count
(Ersätt commit_count med antalet åtaganden som du vill redigera.) Detta kommando startar din editor. Markera det första engagemanget (det som du vill ändra) som "redigera" istället för "plocka", spara och avsluta sedan din redaktör. Gör den förändring du vill begå och kör sedan
git commit --amend
git rebase - fortsätt
Obs: Du kan också "Gör den ändring du vill ha" från redigeraren som öppnas av git commit --amend
|
Som redannämnts, git commit - ändring är sättet att skriva över det senaste engagemanget. En anmärkning: om du också vill skriva över filerna skulle kommandot vara
git commit -a --amend -m "My new commit message"
|
Du kan också använda git filtergren för det.
git filter-branch -f --msg-filter "sed's / errror / error / '" $ flawed_commit..HEAD
Det är inte lika enkelt som ett trivialt git-engagemang - ändra, men det är särskilt användbart om du redan har några sammanslagningar efter ditt felaktiga meddelande.
Observera att detta kommer att försöka skriva om varje engagemang mellan HEAD och det felaktiga engagemanget, så du bör välja ditt msg-filter-kommando mycket klokt ;-)
|
Jag föredrar detta sätt:
git commit --amend -c 
Annars kommer ett nytt engagemang med ett nytt engagemangs-ID.
|
Om du använder Git GUI-verktyget finns det en knapp som heter Amend last commit. Klicka på den knappen så visas de senaste kommandofilerna och meddelandet. Redigera bara meddelandet så kan du begå det med ett nytt meddelande.
Eller använd det här kommandot från en konsol / terminal:
git commit -a --amend -m "My new commit message"
|
Du kan använda Git rebasing. Till exempel, om du vill ändra tillbaka för att begå bbc643cd, kör
$ git rebase bbc643cd ^ - interaktiv
I standardredigeraren ändrar du 'plocka' till 'redigera' på raden vars engagemang du vill ändra. Gör dina ändringar och sedan iscensätta dem med
$ git lägg till 
Nu kan du använda
$ git commit --amend
för att ändra åtagandet och därefter
$ git rebase - fortsätt
för att återgå till föregående huvudförpliktelse.
|
Om du bara vill ändra ditt senaste meddelande, gör sedan:
git commit --amend
Det kommer att släppa dig in i din textredigerare och låta dig ändra det senaste meddelandet.
Om du vill ändra de tre senaste kommuniceringsmeddelandena eller något av kommuniceringsmeddelandena fram till den punkten, leverera HEAD ~ 3 till kommandot git rebase -i:
git rebase -i HEAD ~ 3
|
Om du måste ändra ett gammalt engagemangsmeddelande över flera grenar (dvs. kommit med felaktigt meddelande finns i flera grenar) kanske du vill använda:
git filter-gren -f --msg-filter \
'sed "s /  /  / g"' - --all
Git kommer att skapa en tillfällig katalog för omskrivning och dessutom säkerhetskopiera gamla referenser i ref / original /.
-f kommer att verkställa genomförandet av operationen. Detta är nödvändigt om den tillfälliga katalogen redan finns eller om det redan finns referenser lagrade under ref / original. Om så inte är fallet kan du släppa den här flaggan.
- separerar filtergrenalternativ från revisionsalternativ.
- Alla ser till att alla grenar och taggar skrivs om.
På grund av säkerhetskopieringen av dina gamla referenser kan du enkelt gå tillbaka till tillståndet innan du kör kommandot.
Säg, du vill återställa din master och komma åt den i filialen old_master:
git checkout -b old_master refs / original / refs / heads / master
|
Använda sig av
git commit --amend
För att förstå det i detalj är ett utmärkt inlägg 4. Omskrivning av Git History. Det talar också om när man inte ska använda git commit --amend.
|
Om det är din senaste förpliktelse, ändra bara förpliktelsen:
git commit --amend -o -m "New commit message"
(Använd flaggan -o (--only) för att se till att du bara ändrar kommuniceringsmeddelandet)
Om det är en begravd begå, använd den fantastiska interaktiva rebasen:
git rebase -i @ ~ 9 # Visa de senaste 9 åtagandena i en textredigerare
Hitta det engagemang du vill ha, ändra valet till r (omformulera) och spara och stäng filen. Gjort!
Miniatyr Vim-handledning (eller hur man gör om med endast 8 tangenttryckningar 3jcwrEscZZ):
Kör vimtutor om du har tid
hjkl motsvarar rörelseknappar ← ↓ ↑ →
Alla kommandon kan prefixas med ett "intervall", t.ex. 3j går ner tre rader
i för att gå in i infogningsläge - text du skriver visas i filen
Esc eller Ctrlc för att avsluta infogningsläget och återgå till "normalt" läge
u att ångra
Ctrlr för att göra om
dd, dw, dl för att radera respektive rad, ord eller bokstav
cc, cw, cl för att ändra en rad, ett ord eller en bokstav respektive (samma som ddi)
yy, yw, yl för att kopiera ("yank") en rad, ett ord eller en bokstav
p eller P för att klistra in efter respektive före aktuell position
: wAnge för att spara (skriva) en fil
: q! Gå in för att avsluta utan att spara
: wqEnter eller ZZ för att spara och avsluta
Om du redigerar text mycket, byt sedan till Dvoraks tangentbordslayout, lär dig att peka-typ och lär dig Vim. Är det värt ansträngningen? Ja.
ProTip ™: Var inte rädd för att experimentera med "farliga" kommandon som skriver om historik * - Git raderar inte dina åtaganden på 90 dagar som standard; du hittar dem i reflogen:
$ git reset @ ~ 3 # Gå tillbaka tre åtaganden
$ git reflog
c4f708b HEAD @ {0}: Återställ: flyttar till @ ~ 3
2c52489 HEAD @ {1}: commit: fler ändringar
4a5246d HEAD @ {2}: commit: gör viktiga ändringar
e8571e4 HEAD @ {3}: commit: gör några ändringar
... tidigare åtar sig ...
$ git återställer 2c52489
... och du är tillbaka där du började
* Se upp för alternativ som - hårt och - tvinga dock - de kan kasta data.
* Skriv inte om historiken på några grenar du samarbetar med.
|
Ändra
Du har ett paralternativ här. Du kan göra
git commit --amend
så länge det är ditt senaste åtagande.
Interaktiv rebase
Annars, om det inte är ditt senaste engagemang, kan du göra en interaktiv rebase,
git rebase -i [branched_from] [hash before commit]
Sedan inuti den interaktiva rebasen lägger du helt enkelt till redigering till det åtagandet. När det kommer upp, gör ett git-engagemang - ändra och ändra meddelandet. Om du vill rulla tillbaka innan den kommunicera punkten, kan du också använda git reflog och bara ta bort det åtagandet. Då gör du bara en git-förpliktelse igen.
|
Om du använder Git GUI kan du ändra det senaste engagemanget som inte har skjutits med:
Begå / ändra senaste åtagande
|
Jag använder Git GUI så mycket jag kan, och det ger dig möjlighet att ändra det senaste åtagandet:
Git rebase -i origin / master är också ett trevligt mantra som alltid ger dig de åtaganden du har gjort ovanpå master och ger dig möjlighet att ändra, ta bort, ordna om eller squash. Inget behov av att få tag på den haschen först.
|
Wow, så det finns många sätt att göra detta.
Ännu ett sätt att göra detta är att ta bort det senaste engagemanget, men behåll ändringarna så att du inte förlorar ditt arbete. Du kan sedan göra ett nytt engagemang med det korrigerade meddelandet. Det här skulle se ut så här:
git reset --soft HEAD ~ 1
git commit -m 'Nytt och korrigerat engagemangsmeddelande'
Jag gör alltid detta om jag glömmer att lägga till en fil eller göra en ändring.
Kom ihåg att ange --soft istället för --hard, annars förlorar du det helt.
|
För alla som letar efter ett Windows / Mac GUI för att hjälpa till med redigering av äldre meddelanden (dvs. inte bara det senaste meddelandet), rekommenderar jag Sourcetree. Stegen att följa finns under bilden.
För åtaganden som inte har skjutits till en fjärrkontroll ännu:
Se till att du har begått eller stashed alla aktuella ändringar (dvs. så att det inte finns några filer listade på fliken "Filstatus") - det fungerar inte annars.
På fliken "Logg / historik" högerklickar du på posten med en angränsande rad i diagrammet nedanför den (de) engagemang som du vill redigera och väljer "Rebase children of  interactively ..."
Välj hela raden för ett meddelande du vill ändra (klicka på kolumnen "Meddelande").
Klicka på knappen "Redigera meddelande".
Redigera meddelandet enligt önskan i dialogrutan som visas och klicka sedan på OK.
Upprepa steg 3-4 om det finns andra meddelanden att ändra.
Klicka på OK: Omgraderingen börjar. Om allt är bra slutar utgången "Slutfört framgångsrikt". OBS: Jag har ibland sett detta misslyckas med att det inte går att skapa 'project_path / .git / index.lock': Filen finns. när du försöker ändra flera meddelanden samtidigt. Inte säker på exakt vad problemet är, eller om det kommer att åtgärdas i en framtida version av Sourcetree, men om detta händer skulle du rekommendera att du byter dem en i taget (långsammare men verkar mer tillförlitlig).
... Eller ... för åtaganden som redan har drivits:
Följ stegen i det här svaret, som liknar ovan, men kräver att ett ytterligare kommando körs från kommandoraden (git push origin  -f) för att tvinga fram grenen. Jag rekommenderar att du läser allt och använder nödvändig försiktighet!
|
Om du bara vill redigera det senaste engagemanget, använd:
git commit --amend
eller
git commit --amend -m 'one line message'
Men om du vill redigera flera åtaganden i rad bör du istället använda omstart:
git rebase -i 
I en fil, som den ovan, skriver du redigera / e eller ett av de andra alternativen och trycka på spara och avsluta.
Nu kommer du till det första fel begå. Gör ändringar i filerna så kommer de automatiskt att arrangeras åt dig. Typ
git commit --amend
Spara och avsluta det och skriv
git rebase - fortsätt
för att gå till nästa val tills du är klar med alla dina val.
Observera att dessa saker förändrar alla dina SHA-hashes efter det specifika engagemanget.
|
Om du bara vill ändra ditt senaste meddelande ska du använda flaggan - endast eller dess genväg - o med commit --ändra:
git commit --amend -o -m "New commit message"
Detta säkerställer att du inte av misstag förbättrar ditt engagemang med iscensatta saker. Naturligtvis är det bäst att ha en korrekt $ EDITOR-konfiguration. Då kan du lämna alternativet -m ute, och Git kommer att fylla i kommuniceringsmeddelandet med det gamla. På detta sätt kan den enkelt redigeras.
|
Uppdatera ditt senaste felmeddelande med det nya meddelandet i en rad:
git commit --amend -m "your new commit message"
Eller försök Git reset som nedan:
# Du kan återställa huvudet till n antal engagemang
# INTE en bra idé för att ändra det senaste meddelandet,
# men du kan få en idé att dela upp i flera åtaganden
git reset --soft HEAD ^
# Det kommer att återställa ditt senaste åtagande. Nu, du
# kan begå det igen med ett nytt engagemangsmeddelande.
Användning av reset för att dela upp åtaganden i mindre åtaganden
git reset kan också hjälpa dig att bryta ett åtagande i flera åtaganden:
# Återställ huvudet. Jag återställer det senaste åtagandet:
git reset --soft HEAD ^
# (Du kan återställa flera åtaganden genom att göra HEAD ~ 2 (antal åtaganden)
# Återställ huvudet fördela den till flera åtaganden
git reset HEAD
# Lägg till och begå dina filer separat för att göra flera åtaganden: t.ex.
git lägg till app /
git commit -m "lägg till alla filer i appkatalogen"
git add config /
git commit -m "lägg till alla filer i konfigurationskatalogen"
Här har du framgångsrikt brutit upp ditt senaste åtagande i två åtaganden.
|
På den här frågan finns det många svar, men ingen av dem förklarar i detalj hur man ändrar äldre meddelanden med hjälp av Vim. Jag satt fast och försökte göra det själv, så här skriver jag ner i detalj hur jag gjorde det speciellt för människor som inte har någon erfarenhet av Vim!
Jag ville ändra mina fem senaste åtaganden som jag redan sköt till servern. Detta är ganska "farligt" för om någon annan redan har hämtat sig från detta kan du förstöra saker genom att ändra kommunicera meddelanden. Men när du arbetar med din egen lilla gren och är säker på att ingen drog i den kan du ändra den så här:
Låt oss säga att du vill ändra dina fem senaste åtaganden och sedan skriva detta i terminalen:
git rebase -i HEAD ~ 5
* Där 5 är antalet engagemangsmeddelanden som du vill ändra (så om du vill ändra det 10: e till det senaste engagemanget skriver du in 10).
Detta kommando tar dig in i Vim där du kan "redigera" din engagemangshistorik. Du ser dina fem senaste åtaganden längst upp så här:
välj  commit-meddelande
I stället för att välja måste du skriva omformulering. Du kan göra detta i Vim genom att skriva i. Det gör att du går in i infogningsläget. (Du ser att du är i infogningsläge med ordet INSERT längst ner.) För de åtaganden du vill ändra, skriv in omformulering istället för att välja.
Då måste du spara och avsluta den här skärmen. Du gör det genom att först gå in i "kommandoläge" genom att trycka på Esc-knappen (du kan kontrollera att du är i kommandoläge om ordet INSERT längst ner har försvunnit). Sedan kan du skriva in ett kommando genom att skriva:. Kommandot för att spara och avsluta är wq. Så om du skriver in: wq är du på rätt spår.
Då kommer Vim att gå igenom alla engagemangsmeddelanden som du vill omformulera, och här kan du faktiskt ändra engagemangsmeddelandena. Du gör detta genom att gå in i infogningsläge, ändra engagemangsmeddelandet, gå in i kommandoläge och spara och avsluta. Gör detta fem gånger så är du ute av Vim!
Sedan, om du redan har tryckt på dina felåtgärder, måste du git push - force för att skriva över dem. Kom ihåg att git push --force är en ganska farlig sak att göra, så se till att ingen drog från servern eftersom du tryckte fel fel!
Nu har du ändrat dina meddelanden!
(Som ni ser är jag inte så erfaren i Vim, så om jag använde fel 'lingo' för att förklara vad som händer, är jag välkommen att korrigera mig!)
|
Du kan använda git-rebase-reword
Den är utformad för att redigera alla commit (inte bara sista) på samma sätt som commit --amend
$ git rebase-reword 
Det är uppkallat efter åtgärden på rebase interaktiv för att ändra en commit: "reword". Se det här inlägget och interaktivt läge för människan -
Exempel:
$ git rebase-reword b68f560
$ git rebase-reword HEAD ^
|
Jag har lagt till alias reci och recm för att återanvända (ändra) det. Nu kan jag göra det med git recm eller git recm -m:
$ vim ~ / .gitconfig
[alias]
......
cm = begå
reci = begå --ändra
recm = begå --ändra
......
|
Jag insåg att jag hade gjort ett åtagande med ett stavfel i det. För att ångra gjorde jag följande:
git commit --amend -m "T-1000, avancerad prototyp"
git push --force
Varning: att trycka kraftigt på dina ändringar kommer att skriva över fjärrgrenen med din lokala. Se till att du inte kommer att skriva över något du vill behålla. Var också försiktig med att tvinga fram ett ändrat (omskrivet) åtagande om någon annan delar filialen med dig, för de kommer att behöva skriva om sin egen historia om de har den gamla kopian av åtagandet som du just har skrivit om.
|
Jag gillar att använda följande:
git-status
git add - allt
git commit -am "meddelandet går här om förändringen"
git pull 
git push 
|
Om du inte har tryckt koden till din fjärrgren (GitHub / Bitbucket) kan du ändra engagemangsmeddelandet på kommandoraden enligt nedan.
git commit --ändra -m "Ditt nya meddelande"
Gör så här om du arbetar med en viss gren:
git commit --amend -m "BRANCH-NAME: new message"
Om du redan har tryckt på koden med fel meddelande och du måste vara försiktig när du ändrar meddelandet. Det vill säga när du ändrar engagemangsmeddelandet och försöker trycka på det igen får du problem. För att göra det smidigt, följ dessa steg.
Läs hela mitt svar innan du gör det.
git commit --amend -m "BRANCH-NAME: your new message"
git push -f origin BRANCH-NAME # Inte en bästa praxis. Läs nedan varför?
Viktig anmärkning: När du använder force push direkt kan du få kodproblem som andra utvecklare arbetar på samma gren. Så för att undvika dessa konflikter måste du dra koden från din filial innan du gör styrkanskjuta på:
git commit --amend -m "BRANCH-NAME: your new message"
git pull origin BRANCH-NAME
git push -f origin BRANCH-NAME
Detta är den bästa praxis när du ändrar kommit-meddelandet, om det redan hade skjutits.
|
Inte svaret du letar efter? Bläddra bland andra frågor taggade git git-commit git-rewrite-history ändra eller ställ din egen fråga.